/**
 * 格式化时间
 * @param {Date} date 日期对象
 * @param {string} format 格式化模式
 * @returns {string} 格式化后的时间字符串
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()
  const hour = date.getHours()
  const minute = date.getMinutes()
  const second = date.getSeconds()
  
  format = format.replace(/YYYY/g, year)
  format = format.replace(/MM/g, month.toString().padStart(2, '0'))
  format = format.replace(/DD/g, day.toString().padStart(2, '0'))
  format = format.replace(/HH/g, hour.toString().padStart(2, '0'))
  format = format.replace(/mm/g, minute.toString().padStart(2, '0'))
  format = format.replace(/ss/g, second.toString().padStart(2, '0'))
  
  return format
}

/**
 * 格式化金额
 * @param {number} amount 金额
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的金额字符串
 */
export function formatAmount(amount, decimals = 2) {
  return Number(amount).toFixed(decimals)
}

/**
 * 格式化手机号
 * @param {string} phone 手机号
 * @returns {string} 格式化后的手机号
 */
export function formatPhone(phone) {
  return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
}

/**
 * 防抖函数
 * @param {Function} fn 要执行的函数
 * @param {number} delay 延迟时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(fn, delay = 300) {
  let timer = null
  return function(...args) {
    if (timer) clearTimeout(timer)
    timer = setTimeout(() => {
      fn.apply(this, args)
    }, delay)
  }
}

/**
 * 节流函数
 * @param {Function} fn 要执行的函数
 * @param {number} delay 延迟时间
 * @returns {Function} 节流后的函数
 */
export function throttle(fn, delay = 300) {
  let timer = null
  let last = 0
  return function(...args) {
    const now = Date.now()
    if (now - last >= delay) {
      fn.apply(this, args)
      last = now
    } else if (!timer) {
      timer = setTimeout(() => {
        fn.apply(this, args)
        last = Date.now()
        timer = null
      }, delay)
    }
  }
}

/**
 * 深拷贝
 * @param {*} obj 要拷贝的对象
 * @returns {*} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj
  
  const clone = Array.isArray(obj) ? [] : {}
  for (let key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      clone[key] = deepClone(obj[key])
    }
  }
  return clone
}

/**
 * 检查是否为空
 * @param {*} value 要检查的值
 * @returns {boolean} 是否为空
 */
export function isEmpty(value) {
  if (value === null || value === undefined) return true
  if (typeof value === 'string' && value.trim() === '') return true
  if (Array.isArray(value) && value.length === 0) return true
  if (typeof value === 'object' && Object.keys(value).length === 0) return true
  return false
}

/**
 * 生成随机字符串
 * @param {number} length 字符串长度
 * @returns {string} 随机字符串
 */
export function randomString(length = 32) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  let result = ''
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length))
  }
  return result
}

/**
 * 检查是否为手机号
 * @param {string} phone 手机号
 * @returns {boolean} 是否为手机号
 */
export function isPhone(phone) {
  return /^1[3-9]\d{9}$/.test(phone)
}

/**
 * 检查是否为邮箱
 * @param {string} email 邮箱
 * @returns {boolean} 是否为邮箱
 */
export function isEmail(email) {
  return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
}

/**
 * 检查是否为身份证号
 * @param {string} idCard 身份证号
 * @returns {boolean} 是否为身份证号
 */
export function isIdCard(idCard) {
  return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(idCard)
}

/**
 * 获取URL参数
 * @param {string} name 参数名
 * @returns {string} 参数值
 */
export function getUrlParam(name) {
  const reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)')
  const r = window.location.search.substr(1).match(reg)
  if (r != null) return decodeURIComponent(r[2])
  return null
}

/**
 * 显示提示信息
 * @param {string} title 提示内容
 * @param {string} icon 图标类型
 * @param {number} duration 显示时间
 */
export function showToast(title, icon = 'none', duration = 2000) {
  uni.showToast({
    title,
    icon,
    duration
  })
}

/**
 * 显示加载提示
 * @param {string} title 提示内容
 */
export function showLoading(title = '加载中...') {
  uni.showLoading({
    title,
    mask: true
  })
}

/**
 * 隐藏加载提示
 */
export function hideLoading() {
  uni.hideLoading()
}

/**
 * 显示模态框
 * @param {string} title 标题
 * @param {string} content 内容
 * @returns {Promise} Promise对象
 */
export function showModal(title, content) {
  return new Promise((resolve, reject) => {
    uni.showModal({
      title,
      content,
      success: (res) => {
        if (res.confirm) {
          resolve()
        } else {
          reject()
        }
      }
    })
  })
}

/**
 * 页面跳转
 * @param {string} url 跳转地址
 * @param {string} type 跳转类型
 */
export function navigate(url, type = 'navigateTo') {
  const methods = {
    navigateTo: uni.navigateTo,
    redirectTo: uni.redirectTo,
    reLaunch: uni.reLaunch,
    switchTab: uni.switchTab
  }
  
  methods[type]({
    url,
    fail: () => {
      showToast('页面跳转失败')
    }
  })
}

/**
 * 检查登录状态
 * @returns {boolean} 是否已登录
 */
export function checkLogin() {
  const token = uni.getStorageSync('token')
  if (!token) {
    showModal('提示', '请先登录')
    navigate('/pages/login/index')
    return false
  }
  return true
}

/**
 * 请求拦截器
 * @param {Object} options 请求配置
 * @returns {Object} 处理后的请求配置
 */
export function requestInterceptor(options) {
  const token = uni.getStorageSync('token')
  if (token) {
    options.header = {
      ...options.header,
      'Authorization': `Bearer ${token}`
    }
  }
  return options
}

/**
 * 响应拦截器
 * @param {Object} response 响应数据
 * @returns {Object} 处理后的响应数据
 */
export function responseInterceptor(response) {
  const { statusCode, data } = response
  
  if (statusCode === 200) {
    if (data.code === 0) {
      return data.data
    } else {
      showToast(data.message || '请求失败')
      return Promise.reject(data)
    }
  } else if (statusCode === 401) {
    uni.removeStorageSync('token')
    showModal('提示', '登录已过期，请重新登录')
    navigate('/pages/login/index')
    return Promise.reject(new Error('未授权'))
  } else {
    showToast('网络错误')
    return Promise.reject(new Error('网络错误'))
  }
}

/**
 * 封装请求方法
 * @param {Object} options 请求配置
 * @returns {Promise} Promise对象
 */
export function request(options) {
  options = requestInterceptor(options)
  
  return new Promise((resolve, reject) => {
    uni.request({
      ...options,
      success: (res) => {
        resolve(responseInterceptor(res))
      },
      fail: (err) => {
        showToast('请求失败')
        reject(err)
      }
    })
  })
}

/**
 * GET请求
 * @param {string} url 请求地址
 * @param {Object} data 请求参数
 * @returns {Promise} Promise对象
 */
export function get(url, data = {}) {
  return request({
    url,
    method: 'GET',
    data
  })
}

/**
 * POST请求
 * @param {string} url 请求地址
 * @param {Object} data 请求参数
 * @returns {Promise} Promise对象
 */
export function post(url, data = {}) {
  return request({
    url,
    method: 'POST',
    data
  })
}

/**
 * PUT请求
 * @param {string} url 请求地址
 * @param {Object} data 请求参数
 * @returns {Promise} Promise对象
 */
export function put(url, data = {}) {
  return request({
    url,
    method: 'PUT',
    data
  })
}

/**
 * DELETE请求
 * @param {string} url 请求地址
 * @param {Object} data 请求参数
 * @returns {Promise} Promise对象
 */
export function del(url, data = {}) {
  return request({
    url,
    method: 'DELETE',
    data
  })
} 